import type { ColumnRule } from "@/api/hmi/config.api";
// 整理表格数据，根据显示规则，将数据转换为表格所需的格式
// 仅限 仅查询类型 使用
export function formatOnlySelectTableData(req_data: any, tableRuleColumns: any) {
  let tableHeaders: any[] = [];
  let tableData: any[] = [];
  // 将数组数据转换为表格所需的格式
  const transformedData: any[] = [];
  // console.log("req_data:", req_data);
  req_data.forEach((item: any) => {
    // 不拷贝 measurements 数组
    const { measurements, ...row } = item;
    // console.log("measurements:", measurements);
    measurements?.forEach((item2: any) => {
      row[item2.name] = item2.value;
    });
    transformedData.push(row);
  });
  // console.log("transformedData:", transformedData);
  if (tableRuleColumns) {
    tableHeaders = tableRuleColumns?.map((item: any) => item.label) || [];
  } else {
    // console.log("req_data:", req_data);
    tableHeaders = [...new Set(req_data[0].measurements.map((item: any) => item.name))];
  }
  tableData = transformedData;
  // 数据校验
  if (!tableHeaders.length) {
    console.warn("未获取到表头数据");
  }
  if (!tableData.length) {
    console.warn("未获取到表格数据");
  }
  // console.log("tableHeaders:", tableHeaders, "tableData:", tableData);
  return {
    tableHeaders,
    tableData,
  };
}

// 批量删除类型 使用
export function formatBatchDeleteTableData(req_data: any, tableRuleColumns: any) {
  // console.log("tableRuleColumns:", tableRuleColumns);

  let tableHeaders: any[] = [];
  let tableData: any[] = [];
  // 将数组数据转换为表格所需的格式
  tableHeaders = tableRuleColumns.map((item: any) => item.label);
  tableData = req_data;
  // console.log("formatBatchDeleteTableData: tableHeaders:", tableHeaders, "tableData:", tableData);
  return {
    tableHeaders,
    tableData,
  };
}

// 批量更新类型 使用
export function formatBatchUpdateTableData(req_data: any, tableRuleColumns: any) {
  // console.log("tableRuleColumns:", tableRuleColumns);

  let tableHeaders: any[] = [];
  let tableData: any[] = [];
  // let groupList: any[] = [];
  // 将数组数据转换为表格所需的格式
  tableHeaders = tableRuleColumns.map((item: any) => item.label);
  tableData = req_data.map((item: any) => {
    return {
      ...item,
      newValue: item["IED Value"],
    };
  });
  // groupList = [...new Set(req_data.map((item: any) => item.group))];
  // console.log("formatBatchUpdateTableData: tableHeaders:", tableHeaders, "tableData:", tableData);
  return {
    tableHeaders,
    tableData,
    // groupList,
  };
}

// com-api-table , hmi-only-select 使用
export function formatHmiOnlySelectTableData(req_data: any, tableRuleColumns: any) {
  // console.log("formatHmiOnlySelectTableData", req_data, tableRuleColumns);
  const tableHeaders = tableRuleColumns.map((item: any) => item.label);
  const tableData = req_data;
  return {
    tableHeaders,
    tableData,
    total: req_data.length,
  };
}

// com-api-table, hmi-batch-update 使用
export function formatHmiBatchUpdateTableData(
  req_data: any,
  tableRuleColumns: any,
  enumKey: string,
  valueKey: string
) {
  console.log("formatHmiBatchUpdateTableData input:", {
    req_data,
    tableRuleColumns,
    enumKey,
    valueKey,
  });
  // let tableHeaders: any[] = [];
  // let tableData: any[] = [];
  // 将数组数据转换为表格所需的格式
  const tableHeaders = tableRuleColumns.map((item: any) => item.label);
  const tableData = req_data.map((item: any, index: number) => {
    // 确保 item 是一个对象
    if (typeof item !== "object" || item === null) {
      console.warn("Invalid item:", item);
      return { newValue: null };
    }
    // 深拷贝防止引用共享导致的意外修改
    const result = {
      ...JSON.parse(JSON.stringify(item)), // 深拷贝原始数据
      _index: index,
      newValue: JSON.parse(JSON.stringify(item[valueKey])), // 深拷贝 newValue
    };

    // if (enumKey && Array.isArray(item[enumKey])) {
    //   result.valueType = "enum";
    // } else if (typeof item[valueKey] === "boolean") {
    //   result.valueType = "boolean";
    // } else if (item[valueKey] === true || item[valueKey] === false) {
    //   result.valueType = "boolean";
    // } else if (typeof item[valueKey] === "number" && !isNaN(item[valueKey])) {
    //   result.valueType = "number";
    // } else if (typeof item[valueKey] === "string") {
    //   result.valueType = "string";
    // }
    // const result = {
    //   ...item,
    //   newValue: item[valueKey],
    //   valueType: type,
    // };
    console.log("formatHmiBatchUpdateTableData item:", item, "result:", result);
    return result;
  });
  const tableType = req_data.map((item: any) => {
    // 确保 item 是一个对象
    if (typeof item !== "object" || item === null) {
      console.warn("Invalid item:", item);
      return { newValue: null };
    }
    // const result = {
    //   ...item,
    //   newValue: item[valueKey],
    // };
    let result = "string";
    if (enumKey && Array.isArray(item[enumKey])) {
      result = "enum";
    } else if (typeof item[valueKey] === "boolean") {
      result = "boolean";
    } else if (item[valueKey] === true || item[valueKey] === false) {
      result = "boolean";
    } else if (typeof item[valueKey] === "number" && !isNaN(item[valueKey])) {
      result = "number";
    } else if (typeof item[valueKey] === "string") {
      result = "string";
    }
    // const result = {
    //   ...item,
    //   newValue: item[valueKey],
    //   valueType: type,
    // };
    // console.log("formatHmiBatchUpdateTableData item:", item, "result:", result);
    return result;
  });
  console.log("formatHmiBatchUpdateTableData output:", { tableHeaders, tableData });
  return {
    th: tableHeaders,
    td: tableData,
    tt: tableType,
    to: req_data.length,
  };
}

export function formatCellValueByValueType(row: any, ruleColumn: any, enumKey?: string) {
  if (!ruleColumn) return "";
  // if (row.valueType === "number") {
  //   return Number(row[ruleColumn.key]).toFixed(3);
  // }
  // 处理普通值
  // 如果类型为 number，则返回数字，并且保留小数点后三位
  if (row.valueType === "number") {
    return Number(row[ruleColumn.key]).toFixed(3);
  }

  // 枚举类型
  if (row.valueType === "enum") {
    const key = enumKey || "Enum";
    const enumList = row[key];
    if (!Array.isArray(enumList)) return "";
    const enumValue = enumList.find((item: any) => item.Value === row[ruleColumn.key]);
    return enumValue?.Desc ?? "";
  }

  // 字符串类型
  if (row.valueType === "string") {
    return row[ruleColumn.key];
  }

  // 布尔类型
  if (row.valueType === "boolean") {
    return row[ruleColumn.key] ? "true" : "false";
  }
}

export function formatCellValue(row: any, ruleColumn: any) {
  if (!ruleColumn) return "";
  // console.log("formatCellValue input:", { row, ruleColumn });
  // 处理组合列
  if (ruleColumn.combine) {
    const values: any = {};
    ruleColumn.combine.columns.forEach((col: any) => {
      values[col] = formatCellValue(row, { key: col });
    });
    // 使用模板字符串替换
    let result: string = ruleColumn.combine.format;
    Object.entries(values).forEach(([key, value]: any) => {
      result = result.replace(`{${key}}`, value);
    });
    return result;
  }

  if (ruleColumn.type && ruleColumn.fix && "number" == ruleColumn.type) {
    // console.log(
    //   "formatCellValue:",
    //   row,
    //   ruleColumn,
    //   Number(row[ruleColumn.key]).toFixed(ruleColumn.fix)
    // );
    return Number(row[ruleColumn.key]).toFixed(ruleColumn.fix);
  }

  // 其他类型
  const value: any = row[ruleColumn.key];
  if (value === null || value === undefined) return "";
  if (typeof value === "object") {
    if (value.value !== undefined && value.unit !== undefined) {
      return `${value.value} ${value.unit}`;
    }
    return JSON.stringify(value);
  }
  // console.log("formatCellValue: ", row, ruleColumn, value);
  return value;
}


/**
 * 判断列是否为布尔类型
 * - 优先使用列配置的 `type === 'boolean'`
 * - 否则根据当前行该列值的实际类型进行判断
 */
export function isBooleanColumn(row: any, column: { key: string; type?: string } | undefined): boolean {
  if (!column) return false;
  if (column.type && column.type === "boolean") return true;
  const value = row?.[column.key];
  return typeof value === "boolean";
}

/**
 * 通用单元格格式化（用于 HMI 各表格组件）
 * - 支持默认数值保留小数（无 fix 时 3 位；fix=0 取整）
 * - 支持按值列与枚举列（valueKey/enumKey）映射到描述
 * - Boolean 类型显示由开关承担，此处返回空串
 */
export function formatDataTableCellValue(
  row: any,
  column: { key: string; fix?: number; type?: string } | undefined,
  opts?: { valueKey?: string; enumKey?: string }
): string {
  if (!row || !column) return "";
  const value = row[column.key];
  if (value === null || value === undefined) return "";

  // 值/枚举映射（默认 Value/Enum，可通过 opts 覆盖）
  const vKey = opts?.valueKey ?? "Value";
  const eKey = opts?.enumKey ?? "Enum";
  if (column.key === vKey) {
    const enumList = row[eKey];
    if (Array.isArray(enumList)) {
      const enumValue = enumList.find((item: any) => item?.Value === value);
      if (enumValue && (enumValue.Desc !== undefined && enumValue.Desc !== null)) {
        return String(enumValue.Desc);
      }
    }
  }

  // Boolean 由 el-switch 显示，这里不再重复输出
  if (typeof value === "boolean") return "";

  // 对象：转 JSON（或按需扩展）
  if (typeof value === "object") return JSON.stringify(value);

  // 数字：默认保留 3 位；fix=0 取整；fix>0 保留相应小数
  if (typeof value === "number") {
    if (column.fix === undefined) return Number(value).toFixed(3);
    if (column.fix === 0) return Math.round(value).toString();
    return Number(value).toFixed(column.fix);
  }

  // 其他：转字符串
  return String(value);
}

/**
 * 创建带配置的格式化函数，便于在组件中直接以 formatCellValue(row, column) 使用
 */
export function createCellFormatter(options?: { valueKey?: string; enumKey?: string }) {
  return (row: any, column: { key: string; fix?: number; type?: string }) =>
    formatDataTableCellValue(row, column, options);
}


/**
 * 计算所有列宽，使其总和等于表格总宽度（如1200px），内容自适应，支持最小宽度
 * @param ruleColumns 所有列的规则对象数组
 * @param tableData 表格数据
 * @return 列宽数组
 */
export function getAllColumnWidths(ruleColumns: ColumnRule[], tableData: any[]): number[] {
  const MIN_WIDTH = 50;
  const PADDING = 32;
  // 采样前10行
  // const sampleRows = tableData;
  // 计算每列内容宽度
  const contentWidths = ruleColumns.map((ruleColumn) => {
    const header = ruleColumn.label || "";
    const headerWidth = calcStrWidth(header);
    // let contentWidth = 2;
    // for (const row of sampleRows) {
    //   const cellContent = formatCellValue(row, ruleColumn);

    //   const cellWidth = calcStrWidth(String(cellContent));
    //   if (cellWidth > contentWidth) contentWidth = cellWidth;
    // }

    // return Math.max(headerWidth, contentWidth) + PADDING;
    return headerWidth + PADDING;
  });
  let totalContentWidth = contentWidths.reduce((a, b) => a + Math.max(b, MIN_WIDTH), 0);
  let widths = contentWidths.map((w) => Math.max(w, MIN_WIDTH));
  // 计算百分比
  const percentList = widths.map((w) => Math.round((w / totalContentWidth) * 10000) / 100);
  // 修正总和为100%
  const percentSum = percentList.reduce((a, b) => a + b, 0);
  if (percentSum !== 100 && percentList.length > 0) {
    percentList[0] += 100 - percentSum;
  }
  return percentList;
}

/**
 * 计算字符串宽度
 * 根据不同字符类型分配对应宽度:
 * - 中文字符: 18px
 * - 数字: 9px
 * - 英文字母: 9px
 * - 标点符号: 6px
 * - 空格: 4px
 * - 其他特殊字符: 12px
 */
function calcStrWidth(str: string): number {
  // 字符宽度映射表
  const charWidthMap: { [key: string]: number } = {
    // 数字
    "0": 9,
    "1": 9,
    "2": 9,
    "3": 9,
    "4": 9,
    "5": 9,
    "6": 9,
    "7": 9,
    "8": 9,
    "9": 9,
    // 标点符号
    "-": 6,
    ":": 6,
    ".": 6,
    ",": 6,
    "(": 6,
    ")": 6,
    "[": 6,
    "]": 6,
    "{": 6,
    "}": 6,
    "!": 6,
    "?": 6,
    // 空格
    " ": 4,
  };

  let width = 0;
  for (let i = 0; i < str.length; i++) {
    const char = str[i];
    if (charWidthMap[char] !== undefined) {
      // 使用映射表中的宽度
      width += charWidthMap[char];
    } else if (/[\u4e00-\u9fa5]/.test(char)) {
      // 中文字符
      width += 9;
    } else if (/[a-zA-Z]/.test(char)) {
      // 英文字母
      width += 9;
    } else {
      // 其他特殊字符
      width += 9;
    }
  }
  console.log("charWidthMap: ", str, width);
  return width;
}
